/**
 * 参数验证工具函数
 */

/**
 * 验证必需参数
 * @param {Object} data - 要验证的数据对象
 * @param {Array} requiredFields - 必需字段数组
 * @returns {Object} 验证结果 {isValid: boolean, message: string}
 */
const validateRequired = (data, requiredFields) => {
  for (const field of requiredFields) {
    if (!data[field] && data[field] !== 0) {
      return {
        isValid: false,
        message: `缺少必需参数: ${field}`
      };
    }
  }
  return { isValid: true };
};

/**
 * 验证邮箱格式
 * @param {string} email - 邮箱地址
 * @returns {boolean} 是否有效
 */
const validateEmail = (email) => {
  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
  return emailRegex.test(email);
};

/**
 * 验证手机号格式
 * @param {string} phone - 手机号
 * @returns {boolean} 是否有效
 */
const validatePhone = (phone) => {
  const phoneRegex = /^1[3-9]\d{9}$/;
  return phoneRegex.test(phone);
};

/**
 * 验证密码强度
 * @param {string} password - 密码
 * @returns {Object} 验证结果 {isValid: boolean, message: string}
 */
const validatePassword = (password) => {
  if (!password || password.length < 6) {
    return {
      isValid: false,
      message: '密码长度不能少于6位'
    };
  }
  
  if (password.length > 20) {
    return {
      isValid: false,
      message: '密码长度不能超过20位'
    };
  }

  // 检查是否包含字母和数字
  const hasLetter = /[a-zA-Z]/.test(password);
  const hasNumber = /\d/.test(password);
  
  if (!hasLetter || !hasNumber) {
    return {
      isValid: false,
      message: '密码必须包含字母和数字'
    };
  }

  return { isValid: true };
};

/**
 * 验证用户名格式
 * @param {string} username - 用户名
 * @returns {Object} 验证结果 {isValid: boolean, message: string}
 */
const validateUsername = (username) => {
  if (!username || username.length < 3) {
    return {
      isValid: false,
      message: '用户名长度不能少于3位'
    };
  }
  
  if (username.length > 20) {
    return {
      isValid: false,
      message: '用户名长度不能超过20位'
    };
  }

  // 只允许字母、数字、下划线
  const usernameRegex = /^[a-zA-Z0-9_]+$/;
  if (!usernameRegex.test(username)) {
    return {
      isValid: false,
      message: '用户名只能包含字母、数字和下划线'
    };
  }

  return { isValid: true };
};

/**
 * 验证分页参数
 * @param {Object} query - 查询参数
 * @returns {Object} 处理后的分页参数 {page: number, limit: number}
 */
const validatePagination = (query) => {
  let { page = 1, limit = 10 } = query;
  
  page = parseInt(page);
  limit = parseInt(limit);
  
  // 确保页码和限制数量为正整数
  page = isNaN(page) || page < 1 ? 1 : page;
  limit = isNaN(limit) || limit < 1 ? 10 : limit;
  
  // 限制每页最大数量
  limit = limit > 100 ? 100 : limit;
  
  return { page, limit };
};

/**
 * 验证文件类型
 * @param {Object} file - 上传的文件对象
 * @param {Array} allowedTypes - 允许的文件类型数组
 * @returns {Object} 验证结果 {isValid: boolean, message: string}
 */
const validateFileType = (file, allowedTypes) => {
  if (!file) {
    return {
      isValid: false,
      message: '未选择文件'
    };
  }

  const fileExtension = file.originalname.split('.').pop().toLowerCase();
  const mimeType = file.mimetype.toLowerCase();

  // 检查文件扩展名
  const allowedExtensions = allowedTypes.map(type => type.toLowerCase());
  if (!allowedExtensions.includes(fileExtension)) {
    return {
      isValid: false,
      message: `不支持的文件类型，仅支持: ${allowedTypes.join(', ')}`
    };
  }

  // 检查MIME类型
  const allowedMimeTypes = {
    'mp3': 'audio/mpeg',
    'wav': 'audio/wav',
    'm4a': 'audio/mp4',
    'mp4': 'video/mp4',
    'mov': 'video/quicktime',
    'jpg': 'image/jpeg',
    'jpeg': 'image/jpeg',
    'png': 'image/png'
  };

  const expectedMimeType = allowedMimeTypes[fileExtension];
  if (expectedMimeType && !mimeType.includes(expectedMimeType.split('/')[0])) {
    return {
      isValid: false,
      message: '文件类型与扩展名不匹配'
    };
  }

  return { isValid: true };
};

/**
 * 验证文件大小
 * @param {Object} file - 上传的文件对象
 * @param {number} maxSize - 最大文件大小（字节）
 * @returns {Object} 验证结果 {isValid: boolean, message: string}
 */
const validateFileSize = (file, maxSize) => {
  if (!file) {
    return {
      isValid: false,
      message: '未选择文件'
    };
  }

  if (file.size > maxSize) {
    const maxSizeMB = (maxSize / 1024 / 1024).toFixed(1);
    return {
      isValid: false,
      message: `文件大小不能超过 ${maxSizeMB}MB`
    };
  }

  return { isValid: true };
};

/**
 * 验证日期格式
 * @param {string} dateString - 日期字符串
 * @param {string} format - 期望的日期格式 ('YYYY-MM-DD' 或 'YYYY-MM')
 * @returns {Object} 验证结果 {isValid: boolean, message: string, date: Date}
 */
const validateDate = (dateString, format = 'YYYY-MM-DD') => {
  if (!dateString) {
    return {
      isValid: false,
      message: '日期不能为空'
    };
  }

  let regex;
  if (format === 'YYYY-MM-DD') {
    regex = /^\d{4}-\d{2}-\d{2}$/;
  } else if (format === 'YYYY-MM') {
    regex = /^\d{4}-\d{2}$/;
  } else {
    return {
      isValid: false,
      message: '不支持的日期格式'
    };
  }

  if (!regex.test(dateString)) {
    return {
      isValid: false,
      message: `日期格式错误，应为 ${format}`
    };
  }

  const date = new Date(dateString);
  if (isNaN(date.getTime())) {
    return {
      isValid: false,
      message: '无效的日期'
    };
  }

  return {
    isValid: true,
    date
  };
};

/**
 * 验证枚举值
 * @param {*} value - 要验证的值
 * @param {Array} allowedValues - 允许的值数组
 * @param {string} fieldName - 字段名称
 * @returns {Object} 验证结果 {isValid: boolean, message: string}
 */
const validateEnum = (value, allowedValues, fieldName = '参数') => {
  if (value && !allowedValues.includes(value)) {
    return {
      isValid: false,
      message: `${fieldName}值无效，允许的值: ${allowedValues.join(', ')}`
    };
  }
  return { isValid: true };
};

module.exports = {
  validateRequired,
  validateEmail,
  validatePhone,
  validatePassword,
  validateUsername,
  validatePagination,
  validateFileType,
  validateFileSize,
  validateDate,
  validateEnum
};
